Technique for Producing Constructed Fares

ABSTRACT

A technique for producing constructed fares that include an arbitrary added to a published fare is described. The techniques determine interior cities that appear with gateway cities in arbitraries for the airline and searches for gateway cities corresponding to the determined interior cities appearing in the arbitraries. The technique applies an arbitrary corresponding to one of the interior cities to a published fare involving one of the gateway cities to produce the constructed fare.

This invention relates to a process for producing constructed fares.

Airlines publish fares for various markets. A market is a city pair suchas NYC-PAR (New York-Paris). For markets involving major cities like theNYC-PAR market, airlines provide published fares, that is, stated pricesfor travel between the two cities. For markets involving minor cities,however, the airlines rely on a process called fare construction toproduce fares that are sometimes called “constructed fares.” Fareconstruction is particularly used for minor markets involvinginternational travel.

In the NYC-PAR market there may be hundreds of published fares withcorresponding rules to combine the fares. However, there are too manymarkets for airlines to actually publish fares for every single market.For example, for the OME-NCE (Nome, Ak./Nice, France) market, there maynot be a published fare because the Nome-Nice market may be too smallfor airlines to actually publish fares. Nevertheless, the airlines needto be able to offer some price for an OME-NCE ticket. The fareconstruction process solves this problem by providing a mechanism to“extend” a published fare with add-ons also called arbitraries, in orderto derive prices to minor cities. An arbitrary, like a published fare,lists two cities. However, unlike cities in a published fare (whichestablish a bidirectional market), the cities in an arbitrary areordered: the first is the gateway (or major) city, and the second is theinterior (or minor) city. Constructed fares can be either two-componentconstructed fares, i.e., one arbitrary combined with one published fareor three-component constructed fares, i.e., two arbitraries combinedwith one published fare. Examples of two-component constructed faresinclude

-   -   OME-NYC arbitrary+NYC-PAR fare=OME-PAR fare    -   NYC-PAR fare+PAR-NCE arbitrary=NYC-NCE fare

As the examples show, the arbitrary can be added to either end of thepublished fare. A three-component constructed fare is shown below, wherearbitraries are added to both sides of the published fare

-   -   OME-NYC arbitrary+NYC-PAR fare+PAR-NCE arbitrary=OME-NCE fare

In general, two-component constructed fares provide prices between aminor city and a major city, while three-component constructed faresprovide prices between two minor cities.

One approach used to fare construction is to use a list of constructedfares called “The Unpublished Fares Product” that is available fromAirline Tariff Publishing Company (ATPCO). ATPCO is an intermediary thatmaintains fares published by airlines and resellers. With “TheUnpublished Fares Product” a cross-product of all arbitraries and allbase fares is determined and provided into a list. That list can containmillions of constructed fares.

In addition, there are rules that govern the fare construction process,many of which date back to times when fare construction was performed byhand on paper. In particular, not all arbitraries can combine with allfares; various table-driven compatibility checks are performed to verifythat a particular combination is acceptable.

SUMMARY

According to an aspect of the present invention, a method of producingconstructed fares that includes an arbitrary added to a published fareis provided. The method is executed in a computer system and the methodincludes determining interior cities that appear with gateway cities inarbitraries for the airline, searching for gateway cities correspondingto the determined interior cities appearing in the arbitraries andapplying an arbitrary corresponding to one of the interior cities to apublished fare involving one of the gateway cities to produce theconstructed fare.

According to a further aspect of the present invention, a method ofproducing a set of constructed international fares for an airline isexecuted in a computer system and includes determining interior citiesthat appear with gateway cities in arbitraries for the airline,searching for gateway cities corresponding to the determined interiorcities appearing in the arbitraries and applying each arbitrarycorresponding to each of the determined interior cities to publishedfares involving the gateway cities to produce the set of constructedfares.

According to a further aspect of the present invention, a computerprogram product resides on a computer readable medium for producingconstructed fares that includes an arbitrary added to a published fare.The computer program product includes instructions for causing acomputer system to determine interior cities that appear with gatewaycities in arbitraries for the airline, search for gateway citiescorresponding to the determined interior cities appearing in thearbitraries and apply an arbitrary corresponding to one of the interiorcities to a published fare involving one of the gateway cities toproduce the constructed fare.

According to a further aspect of the present invention, a computerprogram product for producing a set of constructed international faresfor an airline resides on a computer readable medium and includesinstructions that cause a computer to determine interior cities thatappear with gateway cities in arbitraries for the airline, search forgateway cities corresponding to the determined interior cities appearingin the arbitraries and apply each arbitrary corresponding to each of thedetermined interior cities to published fares involving the gatewaycities to produce the set of constructed fares.

According to a further aspect of the present invention, a computersystem includes a processor and a memory for storing instructionsexecuted by the processor. The system also includes a storage mediumstoring a computer program product for producing a set of constructedinternational fares for an airline. The computer program productincludes instructions that cause the processor to determine interiorcities that appear with gateway cities in arbitraries for the airline,and search for gateway cities corresponding to the determined interiorcities appearing in the arbitraries. The program also includesinstructions that cause the processor to apply each arbitrarycorresponding to each of the determined interior cities to publishedfares involving the gateway cities to produce the set of constructedfares.

One or more of the following advantages may be provided from one or moreaspects of the invention. The fare construction process produces“constructed fares” in a computational efficient manner. The fareconstruction process dynamically produces constructed fares. That is,because of the efficiency of the algorithm the fare construction processcan produce constructed fares on an “as needed basis”, using the mostcurrent information such as currency conversion factors, prices, fares,and fare construction tables. The fare construction process produces twoand three component constructed fares. The fare construction processproduces the fares efficiently, since although the process isquadruple-nested, branching factors at each loop level are generallysmall, because there are relatively few gateway cities for a giveninterior city.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing features and other aspects of the invention will bedescribed in further detail by the accompanying drawings, in which:

FIG. 1 is a block diagram of a computer system having a fareconstruction process to produce constructed fares.

FIG. 2A-2D are block diagrams showing use of hash tables used to storedata for use by the fare construction process.

FIG. 3A-3B are flow charts showing a fare construction process used inthe system of FIG. 1 to produce two component constructed fares.

FIG. 4A-4C are flow charts showing a fare construction process used inthe system of FIG. 1 to produce two and three component constructedfares.

FIG. 5 is a flow chart showing use of a memorization process for ruleretrieval.

DESCRIPTION

Referring now to FIG. 1, a computer system 10 includes a CPU 12, mainmemory 14 and persistent storage device 16 all coupled via a computerbus 18. The system 10 also includes output devices such as a display 20and a printer 22 (not shown), as well as user input devices such as akeyboard 24 and a mouse 26. Not shown in FIG. 1, but would necessarilybe included in a system of FIG. 1, are software drivers and hardwareinterfaces to couple all the aforementioned elements to the CPU 12.

The computer system 10 also includes a fare construction process 40 thatproduces constructed fares generally between international origins anddestinations of travel. The fare construction process 40 may reside onthe computer system 10 or may reside on a server, not shown, in aconventional manner such as in a client-server arrangement.

The fare construction process 40 can be used as part of a travelplanning system. The fare construction process 40 can access a database20 a. The database 20 a can store the Airline Tariff Publishing Companydatabase of published airline fares and construction tables. Thedatabase 20 a can be stored locally and updated periodically byaccessing a remote resource (not shown) that maintains the database.

One approach to produce a large number of constructed fares can generatea list, and generally a complete list, of all possible constructedfares. This process could be based on an algorithm that forms all legalcombinations of all arbitraries with all published fares and stores themin a table of fares. One way of doing this would use an algorithm thatloops for each airline for each of four cities as shown below.

loop: for each airline a, loop: for each city, c1 loop: for each city,c2 loop: for each city, c3, try to construct fares for airline a,c1-c2-c3 loop: for each city, c4, try to construct fares for airline a,c1-c2-c3-c4

This process is not efficient because there are far too many cities tomake this a practical approach. Assume there are 1000 cities withairports, (there are actually far more than that), then the running timeof this process is proportional to 1000⁴ or some one trilliondeterminations. This may be far too many determinations for even thefastest computers particularly if it is necessary to have access to themost current information to produce a constructed fare implying that theprocess should be run on as needed basis.

Referring now to FIGS. 2A-2D, preprocessing 30 to precompute 32 a firsthash table 37 a to produce a list 38 a of gateway cities {C2} (FIG. 2B),to precompute 34 a second hash table 37 b to produce a second list 38 bof gateway cities {C3} (FIG. 2C), and to precompute 36 a third hashtable 37 c to produce a list 38 a of interior cities {C4} (FIG. 2D) isshown. The first hash table 37 a is constructed 32 such that when thefare construction process accesses the table by an (airline,interior-city) pair the hash table 37 a returns in constant time, thelist 38 a of gateway cities {C2} for which an airline “A” hasarbitraries that specify the interior city C1. The second hash table 37b is constructed such that when the fare construction process accessesthe second hash table 37 b by an (airline, gateway) pair the tablereturns the list 38 b of gateway cities {C3} that the airline “A”publishes fares from the specified gateway C2 to another gateway cityC3. The third hash table 37 c is constructed 36 such that when the fareconstruction process accesses the table by an (airline-gateway pair) thehash table 37 c returns, the list 38 c of interior cities {C4} for whichan airline “A” has arbitraries that specify the gateway city C3. Thesehash tables are used by the fare construction process 40 (FIGS. 3A-3B)or 40′ (FIGS. 4A-4C), as described below.

The first hash table 37 a is produced 32 by iterating over allarbitraries. For each arbitrary A, a hash table entry H for thearbitrary A's interior city is located (or produced, if it does notexist). The arbitrary A's gateway city is added to a hash table entry Hgateway city list. A gateway city entry in the gateway city listindicates that it is possible to use an arbitrary to get from A'sinterior to A's gateway city. Once all arbitraries have been processedthis way, duplicates are removed from all the lists of interior-cities.

The second hash table 37 b is produced 34 in a similar manner. Thedifference is that the process to produce 34 the second hash tableiterates over the set of all international published fares rather thanthe set of all arbitraries.

The third hash table 37 c is produced 36 by iterating over allarbitraries. For each arbitrary A, a hash table entry H for thearbitrary A's gateway city is located (or produced, if it does notexist). The arbitrary A's interior city is added to a hash table entry Hinterior city list. An interior city entry in the interior city listindicates that it is possible to use an arbitrary to get from A'sgateway to A's interior city. Once all arbitraries have been processedthis way, duplicates are removed from all the lists of interior-cities.

Producing the hash tables is quite efficient. The process that producesthe hash tables can run in a time that is proportional to the number ofarbitraries for the first table 37 a and third table 37 c or the numberof fares for second table 37 b. Once the hash tables 37 a, 37 b, 37 chave been produced, they only need to be modified during the fareconstruction process if there is a change (i.e., addition or removal) inarbitraries or gateway cities. Thus, in general, the hash tableproduction process is a small, one-time fixed cost.

Referring now to FIGS. 3A-3B, a fare construction process 40 thatproduces “constructed fares” in a computational efficient manner isshown. The fare construction process 40 produces two componentconstructed fares for the airlines. A process to produce two and threecomponent constructed fares is described in conjunction with FIGS.4A-4C.

This fare construction process 40 makes the computation process moreefficient since it takes into consideration that very few cities areactually part of arbitraries. In other words, the complete set ofarbitraries on all carriers only covers a small portion of the total setof cities. One key to rapidly enumerating constructed fares, therefore,is to start only with interior cities known to appear in somearbitraries. In addition, this algorithm also takes into considerationthat there is no need to consider all cities in the world for thegateway cites. Rather, it is only necessary to consider those cities asgateways if the city is involved in some arbitrary whose interior cityis the city currently being examined in the process.

Pseudocode for the fare construction process 40 would be:

loop: for each airline a, loop: for each city, c1, the interior city insome arbitrary for airline a, loop: for each city, c2, for which somearbitrary c1-c2 exists for airline a, loop: for each city, c3, for whichsome published fare c2-c3 exists for airline a, try to construct faresfor airline a, c1-c2-c3

The fare construction process 40 determines 42 constructed fares foreach airline “A.” The fare construction process 40 only considers faresfrom the same airline since international fare combining rules generallyprohibit combining fares from different airlines. In general, currentlythe airline codes must be an exact match. However, if the rules were tochange to allow affiliates or airlines that have the same corporateparent to be used to construct fares, the process could be modified totake this into consideration. For example, the hash table could includethe affiliates or other airline in the hash tables and return them inthe lists when accessed by the system. The fare construction process 40eliminates many impossible combinations. That is, if the fareconstruction process 40 is producing constructed fares for a givenairline it does not matter if fares can be constructed with otherairlines. This recognition significantly limits the number of usablegateways for any given airline and significantly speeds up the process.

The fare construction process 40 retrieves 44 an interior city from alist of interior cities “C1” that are part of an arbitrary for theairline “A.” The fare construction process 40 retrieves 44 a city C2from the list 38 a (via an access to the first hash table 37 a) of allof the cities “C2” that form arbitraries C1-C2 for city “C1” for airline“A.” The constructed fares process 30 retrieves from the list 38 b (viaan access to the second hash table 38 a) a city “C3” that forms apublished fare with city “C2” for airline “A.” The fare constructionprocess 40 tries 50 to produce a constructed fare for the C1-C2-C3 citycombinations. This embodiment of the fare construction process 40produces the two-component constructed fares, i.e., one arbitrarycombined with one published fare.

The fare construction process 40 will determine 52 if the C1-C2-C3constructed fare is valid. If it is valid it is stored 54 or otherwisenoted, and then a pointer (not shown) is incremented to get the next C3city. If there are more C3 cities, the fare construction process willretrieve the next gateway city C3 for which a published fare exists withC2 that is all of the cities that form a published fare with gatewaycity C2 and the fare construction process will continue. If all citiesC3 have been tested, it will then retrieve the next C2 city byincrementing another pointer (not shown) to get the next C2 city. Ifthere are more C2 cities, the fare construction process 40 will retrievethe next gateway city C2 for which an arbitrary exists with city C1 andthe fare construction process 40 will continue.

If all C2 cities have been tested, it will then retrieve the next C1city by incrementing another pointer (not shown) to get the next C1city. If there are more C1 cities, the fare construction process willretrieve the next interior city C1 will continue. If all interior citiesC1 have been tested, it will then retrieve the next airline byincrementing another pointer (not shown) to get the next airline.

Referring now to FIGS. 4A-4C, a fare construction process 40′ toconstruct two and three-component constructed fares, i.e., twoarbitraries combined with one published fare is shown. In the embodiment40′, there is an additional loop. The fare construction process 40′ issimilar to the process 40 up to when the fare construction process tries50 to construct a two-component constructed fare. The fare constructionprocess 40′ retrieves 51 a a second interior city C4 from a list ofinterior cities “C4” that are part of an arbitrary that exists for cityC3 for the airline “A.” The fare construction process 40 retrieves 44 acity C4 from the list 38 c (via an access to the third hash table 37 c)of all of the cities “C4” that form arbitraries C3-C4 for gateway city“C3” for airline “A.” The fare construction process 40′ tries 51 b toproduce a constructed fare for the C1-C2-C3-C4 city combinations. Thefare construction process 40 will determine 51 c if the C1-C2-C3-C4constructed fare is valid. If it is valid it is stored 54 a or otherwisenoted, and then a pointer (not shown) is incremented to get 51 d thenext C4 city. If there are more C4 interior cities, the fareconstruction process 40′ will retrieve the next interior city C4 and thefare construction process will continue. If all cities C4 have beentested, it will continue from testing 52 the C1-C2-C3 two componentconstructed fare as described above. This embodiment 40′ producestwo-component and three-component constructed fares, i.e., twoarbitraries combined with one published fare.

Pseudocode for the fare construction process 401 is:

loop: for each airline a, loop: for each city, c1, the interior city insome arbitrary for airline a, loop: for each city, c2, for which somearbitrary c1-c2 exists for airline a, loop: for each city, c3, for whichsome published fare c2-c3 exists for airline a, try to construct faresfor airline a, c1-c2-c3 loop: for each city, c4, for which somearbitrary c3-c4 exists for airline a, try to construct fares for airlinea, c1-c2-c3-c4

The fare construction process 40′ produces the fares efficiently, sincealthough the process is still quadruple-nested, branching factors ateach loop level are generally small, because there are relatively fewgateway cities for a given interior city. So, although the running timeis still proportional to k⁴, the value of k at any level is typicallyk=10-20 instead of k=1000.

The fare construction process 40 or 40′ produces these faresdynamically. That is, because of the efficiency of the algorithm thefare construction process 40 or 40′ can produce constructed fares on anas needed basis using the most current information such as currencyconversion factors, prices, fares, and construction tables.

A valid constructed, international fare can have either one or twoarbitraries. Current ATPCO rules permit one arbitrary and one base fareor two arbitraries and a base fare. The ATPCO rules do not permit morethan two arbitraries. The fare construction process 40 finds thoseinterior cities that, for a given airline, are part of an arbitrary. Forthose interior cities, the fare construction process 40 uses aspotential gateways those cities for which it is a gateway city in somearbitrary with those interior cities, rather than using every possibleairport as a gateway. With the selected lists of potential gateways andarbitraries, the fare construction process 40 tries to form aconstructed fare. This fare construction process 40 involves forming across product of all of the cities C1, C2, and C3 and testing theresulting constructed fare against fare rules to see if it is a validconstructed fare.

For any city, there is a manageable number of arbitraries, e.g., 0.1 to10 s for example. Therefore, given such a set there is a manageablenumber of cities that are involved in an arbitrary. The fareconstruction process 40 therefore constructs fares by examining a smallnumber of gateways and arbitraries for only those gateways. Thus, thisfare construction process 40 can construct all potential constructedfares throughout the whole world on all airlines.

Trying to construct a fare for a city combination involves evaluatingthe constructed fares against fare rules. Although, these rules areextensive, the process described herein makes use of several approachesthat speed up aspects of the rule evaluation process. The fareconstruction process 40, 40′ (FIGS. 3A-3B and 4A-4C) is governed by aset of tables called fare construction tables. One of these tablesincludes a list of so called “PO2” records. The PO2 list of records ismaintained by ATPCO from information set by airlines. The PO2 list ofrecords is a set of rules that specify how fares can be combined witharbitraries. Each airline places its entries in the PO2 list of records.The PO2 list of records exist so that any fare that the airlinepublishes will not automatically combine with any arbitrary that theairline publishes. For example, a very cheap fare may not be combinablewith an arbitrary that can reach a luxury destination. The PO2 list ofrecords control this process by limiting what base fares an arbitrarycan combine with.

The PO2 list of records are structured for each fare on a carrier and isspecific to a market. For example, on a New York to London fare, the PO2list of records will govern what arbitrary classes the New York toLondon fare may combine with.

When the airline fare construction process 40 or 40′ producescombinations of city pairs before actually producing a constructed farefrom a published fare and one or two arbitraries, the fare constructionprocess 40 determines if it is a valid combination. One check that isperformed is against PO2 records.

In determining whether or not a fare can combine with an arbitrary, thefare construction process 40 checks 84 the “PO2” records correspondingto the fare. If the PO2 records do not list the arbitrary's fare code,the arbitrary cannot combine with the fare, and the construction isprohibited. The conventional process of finding the set of PO2 recordsmatching a particular fare is time consuming. Alternatively, the checkof fare construction tables can be done on a batch basis after allpotential constructed fare combinations have been determined.

Referring now to FIG. 5, to save time when constructing large numbers offares, a PO2 procedure retrieval 80 uses a process called memorization.Memorization is a technique for speeding up certain kinds of algorithms.If an expensive procedure is called many times, and if the procedure'soutput depends only on the input (i.e., the answer is not dependent onany external factors, such as the current time), then memorization canbe used. To memorize PO2 retrieval, the PO2 procedure call 80 forms aquery 82 involving the constructed fare. The memorization retrievalprocess 80 has a store 88 of past queries and associated answers. If thememorization retrieval process 80 determines that the query has beenstored, it is retrieved from the store 92. Otherwise, a procedure callfor the PO2 record is produced and used to access the record from aremote database. The answer from the remote database is stored in thememorization store 88 for future references.

For subsequent calls for the record, the output from the memorizationstore 88 is used in response to a retrieval query for the PO2 records asit is called on every different input. That is, once the output for acertain input has been stored (i.e., the procedure has been called onthat input once), the procedure does not need to be run again on thatinput. For the next call to the procedure on that input, the value issimply looked up in the memorization table. Because the PO2 matchingprocess needs to be run many times for a single fare, memorization alsoimproves performance.

The construction tables also include so-called PO4 records. These alsolimit which fares can combine with which arbitraries, and also require anon-trivial lookup process. In some cases, memorization of the PO4record lookup process also improves performance. Memorization can beused with other non-trivial rule retrievals when testing fares.

The fare construction process 40′ (FIG. 4A-4C) efficiently enumeratesall possible constructed fares. The fare construction process 40′ can bemodified to generate subsets of constructed fares. Exemplary subsets areall of the constructed fares on a specific airline or all of theconstructed fares through a particular gateway. The fare constructionprocess 40′ can be modified to include conditional statements such as“if . . . then” clauses into the fare construction process 40′. Forexample, to limit construction to one airline R, the second loop 44 ofthe process can include a condition, like:

loop: for each airline a, if (a = R) loop: for each city, c1, theinterior city in some arbitrary for airline a, ..where “R” is a code for a specific airline. The modification willproduce only fares for the airline specified by “R”.

The other loops can be similarly conditioned. In general, the processcan be modified to produce fares matching this pattern:

-   -   cxr interior1 gateway1 gateway2 interior2 fare-basis components        where any combination of these elements can be allowed to vary,        and where “cxr” is an airline code, “interior1” is the first        interior city in a constructed fare, “gateway1” is the first        gateway city in a published fare, “gateway2” is the second city        in the published fare, “interior2” is the second city in a        constructed fare, “fare-basis” is a one to eight character code        or name of a fare type, and “components” is the number of fare        components, i.e., two or three. For example, calling the        algorithm with the setting    -   UA OME <any> <any> NCE <any> <any>        will produce all United Airlines constructed fares from Nome to        Nice via any gateways, with any fare basis, and with any number        of components (two or three).        Pseudocode for the algorithm modified to support these options        follows.

loop: for each airline a, if cxr = <any>, or cxr = a then loop: for eachcity, c1, the interior city in some arbitrary for airline a, ifinterior1 = <any>, or interior1 = c1 then loop: for each city, c2, forwhich some arbitrary c1-c2 exists for airline a, if gateway1 = <any>, orgateway1 = c2 then loop: for each city, c3, for which some publishedfare c2-c3 exists for airline a, if gateway2 = <any>, or gateway2 = c3then try to construct fares for airline a, c1-c2-c3, and store in arrayX if fare-basis /= <any> then remove fares from X not matchingfare-basis if components = <any> or components = 2 then emit faresremaining in X if components = <any>, or components = 3 then loop: foreach city, c4, for which some arbitrary c3-c4 exists for airline a, ifinterior2 = <any> or interior2 = c4 then try to construct fares forairline a, c1-c2-c3-c4 and store in array Y if fare-basis /= <any> thenremove fares from Y not matching fare-basis emit fares remaining in Y

OTHER EMBODIMENTS

It is to be understood that while the invention has been described inconjunction with the detailed description thereof, the foregoingdescription is intended to illustrate and not limit the scope of theinvention, which is defined by the scope of the appended claims. Otheraspects, advantages, and modifications are within the scope of thefollowing claims.

1. A method of producing constructed fares that includes an arbitrary added to a published fare, said method executed in a computer system, the method comprising: determining interior cities that appear with gateway cities in arbitraries for the airline; searching for gateway cities corresponding to the determined interior cities appearing in the arbitraries; and applying an arbitrary corresponding to one of the interior cities to a published fare involving one of the gateway cities to produce the constructed fare.
 2. The method of claim 1 wherein determining interior cities comprises: accessing a hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city.
 3. The method of claim 2 wherein accessing a hash table returns the list in constant time.
 4. The method of claim 1 wherein searching for gateway cities comprises: accessing a hash table by an airline, gateway pair to return a list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 5. The method of claim 1 wherein determining interior cities comprises: accessing a first hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city; and wherein searching for gateway cities comprises: accessing a second hash table by an airline, gateway pair to return a second list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 6. The method of claim 5 wherein accessing the first and second hash table returns the lists in constant time.
 7. The method of claim 1 wherein applying arbitraries further comprises: evaluating records from fare construction tables to determine whether the constructed fare is a valid constructed fare.
 8. The method of claim 1 wherein the method is conditioned to allow any one or more of an airline code, interior city a first gateway city a second gateway city, or fare-basis to vary.
 9. The method of claim 7 wherein testing entries further comprises: determining if an entry in a construction table was memorized before accessing the construction table; and if the entry was memorized, retrieving an answer from a store of memorized entries to apply to the constructed fare.
 10. The method of claim 1 wherein the constructed fare is a two component constructed fare.
 11. The method of claim 1, further comprising: determining a second set of interior cities that appear with a second gateway city in the published fare for the airline; applying a second interior city from the second set of interior cites to the constructed fare to produce a three component constructed fare.
 12. The method of claim 1 wherein the method is performed over all determined interior cities and all gateways.
 13. The method of claim 1 wherein the method is performed over all airlines.
 14. A method of producing a set of constructed international fares for an airline, the method executed in a computer system and the method comprising: determining interior cities that appear with gateway cities in arbitraries for the airline; searching for gateway cities corresponding to the determined interior cities appearing in the arbitraries; and applying each arbitrary corresponding to each of the determined interior cities to published fares involving the gateway cities to produce the set of constructed fares.
 15. The method of claim 14 wherein the set of constructed fares are two component constructed fares.
 16. The method of claim 14 further comprising: determining a second set of interior cities that appear with second gateway cities in the published fares.
 17. The method of claim 15 wherein the set of constructed fares is a first set of constructed fares and the method further comprises: applying each arbitrary corresponding to each of the determined second set of interior cities to the first set of constructed fares to produce a second set of constructed fares.
 18. The method of claim 14 wherein the first set of constructed fares are two component constructed fares and the second set of constructed fares are three component constructed fares.
 19. The method of claim 14 further comprising: evaluating entries in fare construction tables to determine whether constructed fares in the set of constructed fares are valid constructed fares; and returning the valid constructed fares as the set of constructed fares.
 20. The method of claim 19 wherein evaluating entries further comprises: determining if an entry in a fare construction table was memorized before accessing the fare construction table; and if the entry was memorized, retrieving an answer from a store of memorized entries to apply to the constructed fare.
 21. The method of claim 14 wherein determining interior cities comprises: accessing a first hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city; and wherein searching for gateway cities comprises: accessing a second hash table by an airline, gateway pair to return a second list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 22. A computer program product residing on a computer readable medium, for producing constructed fares that includes an arbitrary added to a published fare, comprising instructions for causing a computer system to: determine interior cities that appear with gateway cities in arbitraries for the airline; search for gateway cities corresponding to the determined interior cities appearing in the arbitraries; and apply an arbitrary corresponding to one of the interior cities to a published fare involving one of the gateway cities to produce the constructed fare.
 23. The computer program product of claim 22 wherein instructions that cause a computer to determine interior cities comprises: accessing a hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city.
 24. The computer program product of claim 23 wherein instructions that cause a computer to access a hash table returns the list in constant time.
 25. The computer program product of claim 22 wherein instructions that cause a computer to search for gateway cities comprises instructions that cause a computer to: access a hash table by an airline, gateway pair to return a list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 26. The computer program product of claim 22 wherein instructions that cause a computer to determine interior cities comprises instructions that cause a computer to: access a first hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city; and wherein instructions that cause a computer to search for gateway cities comprises instructions that cause a computer to: access a second hash table by an airline, gateway pair to return a second list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 27. The computer program product of claim 26 wherein instructions that cause a computer to access the first and second hash table returns the lists in constant time.
 28. The computer program product of claim 22 wherein instructions that cause a computer to apply arbitraries further comprises instructions that cause a computer to: test entries in construction tables to determine whether the constructed fare is a valid constructed fare.
 29. The computer program product of claim 28 wherein instructions that cause a computer to test entries further comprises instructions that cause a computer to: determine if an entry in a construction table was memorized before accessing the construction table; and if the entry was memorized, retrieve an answer from a store of memorized entries to apply to the constructed fare.
 30. The computer program product of claim 22 wherein the constructed fare is a two component constructed fare.
 31. The computer program product of claim 22 wherein the computer program product is conditioned to allow any one or more of an airline code, interior city, a first gateway city, a second gateway city, or fare-basis to vary.
 32. The computer program product of claim 22, further comprising instructions that cause a computer to: determine a second set of interior cities that appear with a second gateway city in the published fare for the airline; and apply a second interior city from the second set of interior cites to the constructed fare to produce a three component constructed fare.
 33. The computer program product of claim 22 wherein the computer program product is executed over all determined interior cities and all gateways.
 34. The computer program product of claim 22 wherein the computer program product is executed over all airlines.
 35. A computer program product for producing a set of constructed international fares for an airline, the computer program product residing on a computer readable medium and comprising instructions that cause a computer to: determine interior cities that appear with gateway cities in arbitraries for the airline; search for gateway cities corresponding to the determined interior cities appearing in the arbitraries; and apply each arbitrary corresponding to each of the determined interior cities to published fares involving the gateway cities to produce the set of constructed fares.
 36. The computer program product of claim 35 wherein the set of constructed fares are two component constructed fares.
 37. The computer program product of claim 35 further comprising instructions that cause a computer to: determine a second set of interior cities that appear with second gateway cities in the published fares.
 38. The computer program product of claim 36 wherein the set of constructed fares is a first set of constructed fares, and the computer program product further comprises instructions that cause a computer to: apply each arbitrary corresponding to each of the determined second set of interior cities to the first set of constructed fares to produce a second set of constructed fares.
 39. The computer program product of claim 35 wherein the first set of constructed fares are two component constructed fares and the second set of constructed fares are three component constructed fares.
 40. The computer program product of claim 35 further comprising instructions that cause a computer to: evaluate entries in fare construction tables to determine whether constructed fares in the set of constructed fares are valid constructed fares; and return the valid constructed fares as the set of constructed fares.
 41. The computer program product of claim 40 wherein instructions that cause a computer to evaluate entries further comprises instructions that cause a computer to: determine if an entry in a fare construction table was memorized before accessing the fare construction table; and if the entry was memorized, retrieve an answer from a store of memorized entries to apply to the constructed fare.
 42. The computer program product of claim 35 wherein instructions that cause a computer to determine interior cities comprises instructions that cause a computer to: access a first hash table by an airline, interior-city pair to return a list of gateway cities for which an airline has arbitraries that specify the interior city; and wherein instructions that cause a computer to search for gateway cities comprises instructions that cause a computer to: access a second hash table by an airline, gateway pair to return a second list of gateway cities that an airline publishes fares from the determined gateway to another gateway city.
 43. A computer system comprising: a processor; a memory for storing instructions executed by the processor; and a storage medium storing a computer program product for producing a set of constructed international fares for an airline, the computer program product comprising instructions that cause the processor to: determine interior cities that appear with gateway cities in arbitraries for the airline; search for gateway cities corresponding to the determined interior cities appearing in the arbitraries; and apply each arbitrary corresponding to each of the determined interior cities to published fares involving the gateway cities to produce the set of constructed fares.
 44. The computer system of claim 43 wherein the system is a stand-alone computer.
 45. The computer system of claim 43 wherein the system is a server computer in a networked, client-server computer system.
 46. The computer system of claim 43 wherein the system is a client computer in a networked, client-server computer system.
 47. A method of evaluating constructed fares against construction tables comprises: forming a query to obtain a record from a construction table to evaluate the validity of a constructed fare; determining whether the query has been stored in a store of past queries and associated answers; if the query has been stored, retrieving the answer from the store to evaluate the constructed fare, otherwise retrieving the record from a remote database; evaluating the constructed fare against the record; and storing an answer from evaluating the constructed fare for future references.
 48. The method of claim 47 wherein the store is a memorization store.
 49. The method of claim 47 wherein once the answer for a certain query has been stored, the procedure does not need to be run again on that query unless the record changes.
 50. The method of claim 47 wherein the construction table is a so called ATPCO PO2 table.
 51. The method of claim 47 wherein the construction table is a so called ATPCO PO4 table. 